home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Python 1.4 / Python 1.4 source / Mac / Lib / toolbox / aetools.py < prev    next >
Encoding:
Python Source  |  1996-09-20  |  6.2 KB  |  221 lines  |  [TEXT/Pyth]
  1. """Tools for use in AppleEvent clients and servers.
  2.  
  3. pack(x) converts a Python object to an AEDesc object
  4. unpack(desc) does the reverse
  5.  
  6. packevent(event, parameters, attributes) sets params and attrs in an AEAppleEvent record
  7. unpackevent(event) returns the parameters and attributes from an AEAppleEvent record
  8.  
  9. Plus...  Lots of classes and routines that help representing AE objects,
  10. ranges, conditionals, logicals, etc., so you can write, e.g.:
  11.  
  12.     x = Character(1, Document("foobar"))
  13.  
  14. and pack(x) will create an AE object reference equivalent to AppleScript's
  15.  
  16.     character 1 of document "foobar"
  17.  
  18. Some of the stuff that appears to be exported from this module comes from other
  19. files: the pack stuff from aepack, the objects from aetypes.
  20.  
  21. """
  22.  
  23.  
  24. from types import *
  25. import AE
  26. import AppleEvents
  27. import MacOS
  28.  
  29. from aetypes import *
  30. from aepack import pack, unpack, coerce, AEDescType
  31.  
  32. Error = 'aetools.Error'
  33.  
  34. # Special code to unpack an AppleEvent (which is *not* a disguised record!)
  35. # Note by Jack: No??!? If I read the docs correctly it *is*....
  36.  
  37. aekeywords = [
  38.     'tran',
  39.     'rtid',
  40.     'evcl',
  41.     'evid',
  42.     'addr',
  43.     'optk',
  44.     'timo',
  45.     'inte',    # this attribute is read only - will be set in AESend
  46.     'esrc',    # this attribute is read only
  47.     'miss',    # this attribute is read only
  48.     'from'    # new in 1.0.1
  49. ]
  50.  
  51. def missed(ae):
  52.     try:
  53.         desc = ae.AEGetAttributeDesc('miss', 'keyw')
  54.     except AE.Error, msg:
  55.         return None
  56.     return desc.data
  57.  
  58. def unpackevent(ae):
  59.     parameters = {}
  60.     while 1:
  61.         key = missed(ae)
  62.         if not key: break
  63.         parameters[key] = unpack(ae.AEGetParamDesc(key, '****'))
  64.     attributes = {}
  65.     for key in aekeywords:
  66.         try:
  67.             desc = ae.AEGetAttributeDesc(key, '****')
  68.         except (AE.Error, MacOS.Error), msg:
  69.             if msg[0] != -1701:
  70.                 raise sys.exc_type, sys.exc_value
  71.             continue
  72.         attributes[key] = unpack(desc)
  73.     return parameters, attributes
  74.  
  75. def packevent(ae, parameters = {}, attributes = {}):
  76.     for key, value in parameters.items():
  77.         ae.AEPutParamDesc(key, pack(value))
  78.     for key, value in attributes.items():
  79.         ae.AEPutAttributeDesc(key, pack(value))
  80.  
  81. #
  82. # Support routine for automatically generated Suite interfaces
  83. # These routines are also useable for the reverse function.
  84. #
  85. def keysubst(arguments, keydict):
  86.     """Replace long name keys by their 4-char counterparts, and check"""
  87.     ok = keydict.values()
  88.     for k in arguments.keys():
  89.         if keydict.has_key(k):
  90.             v = arguments[k]
  91.             del arguments[k]
  92.             arguments[keydict[k]] = v
  93.         elif k != '----' and k not in ok:
  94.             raise TypeError, 'Unknown keyword argument: %s'%k
  95.             
  96. def enumsubst(arguments, key, edict):
  97.     """Substitute a single enum keyword argument, if it occurs"""
  98.     if not arguments.has_key(key):
  99.         return
  100.     v = arguments[key]
  101.     ok = edict.values()
  102.     if edict.has_key(v):
  103.         arguments[key] = edict[v]
  104.     elif not v in ok:
  105.         raise TypeError, 'Unknown enumerator: %s'%v
  106.         
  107. def decodeerror(arguments):
  108.     """Create the 'best' argument for a raise MacOS.Error"""
  109.     errn = arguments['errn']
  110.     errarg = (errn, )
  111.     if arguments.has_key('errs'):
  112.         errarg = errarg + (arguments['errs'],)
  113.     if arguments.has_key('erob'):
  114.         errarg = errarg + (arguments['erob'],)
  115.     if len(errarg) == 1:
  116.         errarg = errarg + ('Server returned error code %d'%errn, )
  117.     return errarg
  118.  
  119. class TalkTo:
  120.     """An AE connection to an application"""
  121.     
  122.     def __init__(self, signature, start=0):
  123.         """Create a communication channel with a particular application.
  124.         
  125.         Addressing the application is done by specifying either a
  126.         4-byte signature, an AEDesc or an object that will __aepack__
  127.         to an AEDesc.
  128.         """
  129.         self.target_signature = None
  130.         if type(signature) == AEDescType:
  131.             self.target = signature
  132.         elif type(signature) == InstanceType and hasattr(signature, '__aepack__'):
  133.             self.target = signature.__aepack__()
  134.         elif type(signature) == StringType and len(signature) == 4:
  135.             self.target = AE.AECreateDesc(AppleEvents.typeApplSignature, signature)
  136.             self.target_signature = signature
  137.         else:
  138.             raise TypeError, "signature should be 4-char string or AEDesc"
  139.         self.send_flags = AppleEvents.kAEWaitReply
  140.         self.send_priority = AppleEvents.kAENormalPriority
  141.         self.send_timeout = AppleEvents.kAEDefaultTimeout
  142.         if start:
  143.             self.start()
  144.         
  145.     def start(self):
  146.         """Start the application, if it is not running yet"""
  147.         import findertools
  148.         import macfs
  149.         
  150.         fss = macfs.FindApplication(self.target_signature)
  151.         findertools.launch(fss)
  152.             
  153.     def newevent(self, code, subcode, parameters = {}, attributes = {}):
  154.         """Create a complete structure for an apple event"""
  155.         
  156.         event = AE.AECreateAppleEvent(code, subcode, self.target,
  157.                     AppleEvents.kAutoGenerateReturnID, AppleEvents.kAnyTransactionID)
  158.         packevent(event, parameters, attributes)
  159.         return event
  160.     
  161.     def sendevent(self, event):
  162.         """Send a pre-created appleevent, await the reply and unpack it"""
  163.         
  164.         reply = event.AESend(self.send_flags, self.send_priority,
  165.                                   self.send_timeout)
  166.         parameters, attributes = unpackevent(reply)
  167.         return reply, parameters, attributes
  168.         
  169.     def send(self, code, subcode, parameters = {}, attributes = {}):
  170.         """Send an appleevent given code/subcode/pars/attrs and unpack the reply"""
  171.         return self.sendevent(self.newevent(code, subcode, parameters, attributes))
  172.     
  173.     #
  174.     # The following events are somehow "standard" and don't seem to appear in any
  175.     # suite...
  176.     #
  177.     def activate(self):
  178.         """Send 'activate' command"""
  179.         self.send('misc', 'actv')
  180.  
  181.     def get(self, _object, _attributes={}):
  182.         """get: get data from an object
  183.         Required argument: the object
  184.         Keyword argument _attributes: AppleEvent attribute dictionary
  185.         Returns: the data
  186.         """
  187.         _code = 'core'
  188.         _subcode = 'getd'
  189.  
  190.         _arguments = {'----':_object}
  191.  
  192.  
  193.         _reply, _arguments, _attributes = self.send(_code, _subcode,
  194.                 _arguments, _attributes)
  195.         if _arguments.has_key('errn'):
  196.             raise Error, decodeerror(_arguments)
  197.  
  198.         if _arguments.has_key('----'):
  199.             return _arguments['----']
  200.     
  201.     
  202. # Test program
  203. # XXXX Should test more, really...
  204.  
  205. def test():
  206.     target = AE.AECreateDesc('sign', 'KAHL')
  207.     ae = AE.AECreateAppleEvent('aevt', 'oapp', target, -1, 0)
  208.     print unpackevent(ae)
  209.     raw_input(":")
  210.     ae = AE.AECreateAppleEvent('core', 'getd', target, -1, 0)
  211.     obj = Character(2, Word(1, Document(1)))
  212.     print obj
  213.     print repr(obj)
  214.     packevent(ae, {'----': obj})
  215.     params, attrs = unpackevent(ae)
  216.     print params['----']
  217.     raw_input(":")
  218.  
  219. if __name__ == '__main__':
  220.     test()
  221.